#include "stdafx.h"


unsigned char data__[1776] = {
    0x60, 0x8B, 0x74, 0x24, 0x24, 0xC7, 0x06, 0x01, 0x23, 0x45, 0x67, 0xC7, 0x46, 0x04, 0x89, 0xAB,
    0xCD, 0xEF, 0xC7, 0x46, 0x08, 0xFE, 0xDC, 0xBA, 0x98, 0xC7, 0x46, 0x0C, 0x76, 0x54, 0x32, 0x10,
    0x8B, 0x44, 0x24, 0x2C, 0x50, 0x33, 0xD2, 0xB9, 0x40, 0x00, 0x00, 0x00, 0xF7, 0xF1, 0x40, 0x5A,
    0x83, 0xEC, 0x40, 0x8B, 0xDC, 0x8B, 0x74, 0x24, 0x68, 0x92, 0x8B, 0xFB, 0x4A, 0x75, 0x41, 0x85,
    0xC0, 0x78, 0x06, 0xC6, 0x04, 0x18, 0x80, 0xEB, 0x03, 0x33, 0xC0, 0x48, 0xB9, 0x40, 0x00, 0x00,
    0x00, 0x2B, 0xC8, 0x03, 0xF8, 0x50, 0x33, 0xC0, 0x47, 0x49, 0xF3, 0xAA, 0x58, 0x85, 0xC0, 0x78,
    0x05, 0x83, 0xF8, 0x38, 0x73, 0x19, 0x50, 0x8B, 0x44, 0x24, 0x70, 0x52, 0x33, 0xD2, 0xB9, 0x08,
    0x00, 0x00, 0x00, 0xF7, 0xE1, 0x89, 0x43, 0x38, 0x89, 0x53, 0x3C, 0x5A, 0x58, 0xEB, 0x01, 0x42,
    0x85, 0xC0, 0x78, 0x07, 0x83, 0xF8, 0x40, 0x73, 0x08, 0xEB, 0x02, 0x33, 0xC0, 0x8B, 0xC8, 0xEB,
    0x05, 0xB9, 0x40, 0x00, 0x00, 0x00, 0x8B, 0xFB, 0xF3, 0xA4, 0x50, 0x52, 0x53, 0x56, 0x8D, 0x74,
    0x24, 0x10, 0x8B, 0x7C, 0x24, 0x74, 0x57, 0x8B, 0x07, 0x8B, 0x5F, 0x04, 0x8B, 0x4F, 0x08, 0x8B,
    0x57, 0x0C, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x84,
    0x07, 0x78, 0xA4, 0x6A, 0xD7, 0x03, 0x06, 0xC1, 0xC0, 0x07, 0x03, 0xC3, 0x8B, 0xF8, 0x8B, 0xE8,
    0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0x56, 0xB7, 0xC7, 0xE8, 0x03,
    0x56, 0x04, 0xC1, 0xC2, 0x0C, 0x03, 0xD0, 0x8B, 0xFA, 0x8B, 0xEA, 0x23, 0xF8, 0xF7, 0xD5, 0x23,
    0xEB, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0xDB, 0x70, 0x20, 0x24, 0x03, 0x4E, 0x08, 0xC1, 0xC1, 0x11,
    0x03, 0xCA, 0x8B, 0xF9, 0x8B, 0xE9, 0x23, 0xFA, 0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x9C,
    0x1F, 0xEE, 0xCE, 0xBD, 0xC1, 0x03, 0x5E, 0x0C, 0xC1, 0xC3, 0x16, 0x03, 0xD9, 0x8B, 0xFB, 0x8B,
    0xEB, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x84, 0x07, 0xAF, 0x0F, 0x7C, 0xF5,
    0x03, 0x46, 0x10, 0xC1, 0xC0, 0x07, 0x03, 0xC3, 0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xFB, 0xF7, 0xD5,
    0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0x2A, 0xC6, 0x87, 0x47, 0x03, 0x56, 0x14, 0xC1, 0xC2,
    0x0C, 0x03, 0xD0, 0x8B, 0xFA, 0x8B, 0xEA, 0x23, 0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D,
    0x8C, 0x0F, 0x13, 0x46, 0x30, 0xA8, 0x03, 0x4E, 0x18, 0xC1, 0xC1, 0x11, 0x03, 0xCA, 0x8B, 0xF9,
    0x8B, 0xE9, 0x23, 0xFA, 0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x9C, 0x1F, 0x01, 0x95, 0x46,
    0xFD, 0x03, 0x5E, 0x1C, 0xC1, 0xC3, 0x16, 0x03, 0xD9, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xF9, 0xF7,
    0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x84, 0x07, 0xD8, 0x98, 0x80, 0x69, 0x03, 0x46, 0x20, 0xC1,
    0xC0, 0x07, 0x03, 0xC3, 0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD,
    0x8D, 0x94, 0x17, 0xAF, 0xF7, 0x44, 0x8B, 0x03, 0x56, 0x24, 0xC1, 0xC2, 0x0C, 0x03, 0xD0, 0x8B,
    0xFA, 0x8B, 0xEA, 0x23, 0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0xB1, 0x5B,
    0xFF, 0xFF, 0x03, 0x4E, 0x28, 0xC1, 0xC1, 0x11, 0x03, 0xCA, 0x8B, 0xF9, 0x8B, 0xE9, 0x23, 0xFA,
    0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x9C, 0x1F, 0xBE, 0xD7, 0x5C, 0x89, 0x03, 0x5E, 0x2C,
    0xC1, 0xC3, 0x16, 0x03, 0xD9, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B,
    0xFD, 0x8D, 0x84, 0x07, 0x22, 0x11, 0x90, 0x6B, 0x03, 0x46, 0x30, 0xC1, 0xC0, 0x07, 0x03, 0xC3,
    0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0x93,
    0x71, 0x98, 0xFD, 0x03, 0x56, 0x34, 0xC1, 0xC2, 0x0C, 0x03, 0xD0, 0x8B, 0xFA, 0x8B, 0xEA, 0x23,
    0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0x8E, 0x43, 0x79, 0xA6, 0x03, 0x4E,
    0x38, 0xC1, 0xC1, 0x11, 0x03, 0xCA, 0x8B, 0xF9, 0x8B, 0xE9, 0x23, 0xFA, 0xF7, 0xD5, 0x23, 0xE8,
    0x0B, 0xFD, 0x8D, 0x9C, 0x1F, 0x21, 0x08, 0xB4, 0x49, 0x03, 0x5E, 0x3C, 0xC1, 0xC3, 0x16, 0x03,
    0xD9, 0x8B, 0xFA, 0x8B, 0xEA, 0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x84, 0x07,
    0x62, 0x25, 0x1E, 0xF6, 0x03, 0x46, 0x04, 0xC1, 0xC0, 0x05, 0x03, 0xC3, 0x8B, 0xF9, 0x8B, 0xE9,
    0x23, 0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0x40, 0xB3, 0x40, 0xC0, 0x03,
    0x56, 0x18, 0xC1, 0xC2, 0x09, 0x03, 0xD0, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xFA, 0xF7, 0xD5, 0x23,
    0xE8, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0x51, 0x5A, 0x5E, 0x26, 0x03, 0x4E, 0x2C, 0xC1, 0xC1, 0x0E,
    0x03, 0xCA, 0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x9C,
    0x1F, 0xAA, 0xC7, 0xB6, 0xE9, 0x03, 0x1E, 0xC1, 0xC3, 0x14, 0x03, 0xD9, 0x8B, 0xFA, 0x8B, 0xEA,
    0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x84, 0x07, 0x5D, 0x10, 0x2F, 0xD6, 0x03,
    0x46, 0x14, 0xC1, 0xC0, 0x05, 0x03, 0xC3, 0x8B, 0xF9, 0x8B, 0xE9, 0x23, 0xF8, 0xF7, 0xD5, 0x23,
    0xEB, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0x53, 0x14, 0x44, 0x02, 0x03, 0x56, 0x28, 0xC1, 0xC2, 0x09,
    0x03, 0xD0, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xFA, 0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x8C,
    0x0F, 0x81, 0xE6, 0xA1, 0xD8, 0x03, 0x4E, 0x3C, 0xC1, 0xC1, 0x0E, 0x03, 0xCA, 0x8B, 0xF8, 0x8B,
    0xE8, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x9C, 0x1F, 0xC8, 0xFB, 0xD3, 0xE7,
    0x03, 0x5E, 0x10, 0xC1, 0xC3, 0x14, 0x03, 0xD9, 0x8B, 0xFA, 0x8B, 0xEA, 0x23, 0xFB, 0xF7, 0xD5,
    0x23, 0xE9, 0x0B, 0xFD, 0x8D, 0x84, 0x07, 0xE6, 0xCD, 0xE1, 0x21, 0x03, 0x46, 0x24, 0xC1, 0xC0,
    0x05, 0x03, 0xC3, 0x8B, 0xF9, 0x8B, 0xE9, 0x23, 0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D,
    0x94, 0x17, 0xD6, 0x07, 0x37, 0xC3, 0x03, 0x56, 0x38, 0xC1, 0xC2, 0x09, 0x03, 0xD0, 0x8B, 0xFB,
    0x8B, 0xEB, 0x23, 0xFA, 0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0x87, 0x0D, 0xD5,
    0xF4, 0x03, 0x4E, 0x0C, 0xC1, 0xC1, 0x0E, 0x03, 0xCA, 0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xF9, 0xF7,
    0xD5, 0x23, 0xEA, 0x0B, 0xFD, 0x8D, 0x9C, 0x1F, 0xED, 0x14, 0x5A, 0x45, 0x03, 0x5E, 0x20, 0xC1,
    0xC3, 0x14, 0x03, 0xD9, 0x8B, 0xFA, 0x8B, 0xEA, 0x23, 0xFB, 0xF7, 0xD5, 0x23, 0xE9, 0x0B, 0xFD,
    0x8D, 0x84, 0x07, 0x05, 0xE9, 0xE3, 0xA9, 0x03, 0x46, 0x34, 0xC1, 0xC0, 0x05, 0x03, 0xC3, 0x8B,
    0xF9, 0x8B, 0xE9, 0x23, 0xF8, 0xF7, 0xD5, 0x23, 0xEB, 0x0B, 0xFD, 0x8D, 0x94, 0x17, 0xF8, 0xA3,
    0xEF, 0xFC, 0x03, 0x56, 0x08, 0xC1, 0xC2, 0x09, 0x03, 0xD0, 0x8B, 0xFB, 0x8B, 0xEB, 0x23, 0xFA,
    0xF7, 0xD5, 0x23, 0xE8, 0x0B, 0xFD, 0x8D, 0x8C, 0x0F, 0xD9, 0x02, 0x6F, 0x67, 0x03, 0x4E, 0x1C,
    0xC1, 0xC1, 0x0E, 0x03, 0xCA, 0x8B, 0xF8, 0x8B, 0xE8, 0x23, 0xF9, 0xF7, 0xD5, 0x23, 0xEA, 0x0B,
    0xFD, 0x8D, 0x9C, 0x1F, 0x8A, 0x4C, 0x2A, 0x8D, 0x03, 0x5E, 0x30, 0xC1, 0xC3, 0x14, 0x03, 0xD9,
    0x8B, 0xEB, 0x33, 0xE9, 0x33, 0xEA, 0x8D, 0x84, 0x05, 0x42, 0x39, 0xFA, 0xFF, 0x03, 0x46, 0x14,
    0xC1, 0xC0, 0x04, 0x03, 0xC3, 0x8B, 0xE8, 0x33, 0xEB, 0x33, 0xE9, 0x8D, 0x94, 0x15, 0x81, 0xF6,
    0x71, 0x87, 0x03, 0x56, 0x20, 0xC1, 0xC2, 0x0B, 0x03, 0xD0, 0x8B, 0xEA, 0x33, 0xE8, 0x33, 0xEB,
    0x8D, 0x8C, 0x0D, 0x22, 0x61, 0x9D, 0x6D, 0x03, 0x4E, 0x2C, 0xC1, 0xC1, 0x10, 0x03, 0xCA, 0x8B,
    0xE9, 0x33, 0xEA, 0x33, 0xE8, 0x8D, 0x9C, 0x1D, 0x0C, 0x38, 0xE5, 0xFD, 0x03, 0x5E, 0x38, 0xC1,
    0xC3, 0x17, 0x03, 0xD9, 0x8B, 0xEB, 0x33, 0xE9, 0x33, 0xEA, 0x8D, 0x84, 0x05, 0x44, 0xEA, 0xBE,
    0xA4, 0x03, 0x46, 0x04, 0xC1, 0xC0, 0x04, 0x03, 0xC3, 0x8B, 0xE8, 0x33, 0xEB, 0x33, 0xE9, 0x8D,
    0x94, 0x15, 0xA9, 0xCF, 0xDE, 0x4B, 0x03, 0x56, 0x10, 0xC1, 0xC2, 0x0B, 0x03, 0xD0, 0x8B, 0xEA,
    0x33, 0xE8, 0x33, 0xEB, 0x8D, 0x8C, 0x0D, 0x60, 0x4B, 0xBB, 0xF6, 0x03, 0x4E, 0x1C, 0xC1, 0xC1,
    0x10, 0x03, 0xCA, 0x8B, 0xE9, 0x33, 0xEA, 0x33, 0xE8, 0x8D, 0x9C, 0x1D, 0x70, 0xBC, 0xBF, 0xBE,
    0x03, 0x5E, 0x28, 0xC1, 0xC3, 0x17, 0x03, 0xD9, 0x8B, 0xEB, 0x33, 0xE9, 0x33, 0xEA, 0x8D, 0x84,
    0x05, 0xC6, 0x7E, 0x9B, 0x28, 0x03, 0x46, 0x34, 0xC1, 0xC0, 0x04, 0x03, 0xC3, 0x8B, 0xE8, 0x33,
    0xEB, 0x33, 0xE9, 0x8D, 0x94, 0x15, 0xFA, 0x27, 0xA1, 0xEA, 0x03, 0x16, 0xC1, 0xC2, 0x0B, 0x03,
    0xD0, 0x8B, 0xEA, 0x33, 0xE8, 0x33, 0xEB, 0x8D, 0x8C, 0x0D, 0x85, 0x30, 0xEF, 0xD4, 0x03, 0x4E,
    0x0C, 0xC1, 0xC1, 0x10, 0x03, 0xCA, 0x8B, 0xE9, 0x33, 0xEA, 0x33, 0xE8, 0x8D, 0x9C, 0x1D, 0x05,
    0x1D, 0x88, 0x04, 0x03, 0x5E, 0x18, 0xC1, 0xC3, 0x17, 0x03, 0xD9, 0x8B, 0xEB, 0x33, 0xE9, 0x33,
    0xEA, 0x8D, 0x84, 0x05, 0x39, 0xD0, 0xD4, 0xD9, 0x03, 0x46, 0x24, 0xC1, 0xC0, 0x04, 0x03, 0xC3,
    0x8B, 0xE8, 0x33, 0xEB, 0x33, 0xE9, 0x8D, 0x94, 0x15, 0xE5, 0x99, 0xDB, 0xE6, 0x03, 0x56, 0x30,
    0xC1, 0xC2, 0x0B, 0x03, 0xD0, 0x8B, 0xEA, 0x33, 0xE8, 0x33, 0xEB, 0x8D, 0x8C, 0x0D, 0xF8, 0x7C,
    0xA2, 0x1F, 0x03, 0x4E, 0x3C, 0xC1, 0xC1, 0x10, 0x03, 0xCA, 0x8B, 0xE9, 0x33, 0xEA, 0x33, 0xE8,
    0x8D, 0x9C, 0x1D, 0x65, 0x56, 0xAC, 0xC4, 0x03, 0x5E, 0x08, 0xC1, 0xC3, 0x17, 0x03, 0xD9, 0x8B,
    0xEA, 0xF7, 0xD5, 0x0B, 0xEB, 0x33, 0xE9, 0x8D, 0x84, 0x05, 0x44, 0x22, 0x29, 0xF4, 0x03, 0x06,
    0xC1, 0xC0, 0x06, 0x03, 0xC3, 0x8B, 0xE9, 0xF7, 0xD5, 0x0B, 0xE8, 0x33, 0xEB, 0x8D, 0x94, 0x15,
    0x97, 0xFF, 0x2A, 0x43, 0x03, 0x56, 0x1C, 0xC1, 0xC2, 0x0A, 0x03, 0xD0, 0x8B, 0xEB, 0xF7, 0xD5,
    0x0B, 0xEA, 0x33, 0xE8, 0x8D, 0x8C, 0x0D, 0xA7, 0x23, 0x94, 0xAB, 0x03, 0x4E, 0x38, 0xC1, 0xC1,
    0x0F, 0x03, 0xCA, 0x8B, 0xE8, 0xF7, 0xD5, 0x0B, 0xE9, 0x33, 0xEA, 0x8D, 0x9C, 0x1D, 0x39, 0xA0,
    0x93, 0xFC, 0x03, 0x5E, 0x14, 0xC1, 0xC3, 0x15, 0x03, 0xD9, 0x8B, 0xEA, 0xF7, 0xD5, 0x0B, 0xEB,
    0x33, 0xE9, 0x8D, 0x84, 0x05, 0xC3, 0x59, 0x5B, 0x65, 0x03, 0x46, 0x30, 0xC1, 0xC0, 0x06, 0x03,
    0xC3, 0x8B, 0xE9, 0xF7, 0xD5, 0x0B, 0xE8, 0x33, 0xEB, 0x8D, 0x94, 0x15, 0x92, 0xCC, 0x0C, 0x8F,
    0x03, 0x56, 0x0C, 0xC1, 0xC2, 0x0A, 0x03, 0xD0, 0x8B, 0xEB, 0xF7, 0xD5, 0x0B, 0xEA, 0x33, 0xE8,
    0x8D, 0x8C, 0x0D, 0x7D, 0xF4, 0xEF, 0xFF, 0x03, 0x4E, 0x28, 0xC1, 0xC1, 0x0F, 0x03, 0xCA, 0x8B,
    0xE8, 0xF7, 0xD5, 0x0B, 0xE9, 0x33, 0xEA, 0x8D, 0x9C, 0x1D, 0xD1, 0x5D, 0x84, 0x85, 0x03, 0x5E,
    0x04, 0xC1, 0xC3, 0x15, 0x03, 0xD9, 0x8B, 0xEA, 0xF7, 0xD5, 0x0B, 0xEB, 0x33, 0xE9, 0x8D, 0x84,
    0x05, 0x4F, 0x7E, 0xA8, 0x6F, 0x03, 0x46, 0x20, 0xC1, 0xC0, 0x06, 0x03, 0xC3, 0x8B, 0xE9, 0xF7,
    0xD5, 0x0B, 0xE8, 0x33, 0xEB, 0x8D, 0x94, 0x15, 0xE0, 0xE6, 0x2C, 0xFE, 0x03, 0x56, 0x3C, 0xC1,
    0xC2, 0x0A, 0x03, 0xD0, 0x8B, 0xEB, 0xF7, 0xD5, 0x0B, 0xEA, 0x33, 0xE8, 0x8D, 0x8C, 0x0D, 0x14,
    0x43, 0x01, 0xA3, 0x03, 0x4E, 0x18, 0xC1, 0xC1, 0x0F, 0x03, 0xCA, 0x8B, 0xE8, 0xF7, 0xD5, 0x0B,
    0xE9, 0x33, 0xEA, 0x8D, 0x9C, 0x1D, 0xA1, 0x11, 0x08, 0x4E, 0x03, 0x5E, 0x34, 0xC1, 0xC3, 0x15,
    0x03, 0xD9, 0x8B, 0xEA, 0xF7, 0xD5, 0x0B, 0xEB, 0x33, 0xE9, 0x8D, 0x84, 0x05, 0x82, 0x7E, 0x53,
    0xF7, 0x03, 0x46, 0x10, 0xC1, 0xC0, 0x06, 0x03, 0xC3, 0x8B, 0xE9, 0xF7, 0xD5, 0x0B, 0xE8, 0x33,
    0xEB, 0x8D, 0x94, 0x15, 0x35, 0xF2, 0x3A, 0xBD, 0x03, 0x56, 0x2C, 0xC1, 0xC2, 0x0A, 0x03, 0xD0,
    0x8B, 0xEB, 0xF7, 0xD5, 0x0B, 0xEA, 0x33, 0xE8, 0x8D, 0x8C, 0x0D, 0xBB, 0xD2, 0xD7, 0x2A, 0x03,
    0x4E, 0x08, 0xC1, 0xC1, 0x0F, 0x03, 0xCA, 0x8B, 0xE8, 0xF7, 0xD5, 0x0B, 0xE9, 0x33, 0xEA, 0x8D,
    0x9C, 0x1D, 0x91, 0xD3, 0x86, 0xEB, 0x03, 0x5E, 0x24, 0xC1, 0xC3, 0x15, 0x03, 0xD9, 0x5F, 0x01,
    0x07, 0x01, 0x5F, 0x04, 0x01, 0x4F, 0x08, 0x01, 0x57, 0x0C, 0x5E, 0x5B, 0x5A, 0x58, 0x83, 0xE8,
    0x40, 0x85, 0xD2, 0x0F, 0x85, 0x51, 0xF9, 0xFF, 0xFF, 0x83, 0xC4, 0x40, 0x61, 0xC2, 0x0C, 0x00
};


//#define DO_TEST_32 0


//void test_on_shellcode();

DWORD WINAPI multithread_test(LPVOID) {
//    test_on_shellcode();
    return 0;
}


int main() {

    //  for (uint32_t i = 0x234235; i < 0xF0000000;i+= 0x10000000) {
    srand(222);
    //test_on_shellcode();

    /*
    HANDLE hthread[2];

    hthread[0] = CreateThread(0, 0, multithread_test, 0, 0, 0);
    hthread[1] = CreateThread(0, 0, multithread_test, 0, 0, 0);
    WaitForMultipleObjects(1, hthread, true, -1);

    system("PAUSE");
    return 0;
    */


    //shibari_module _module(
    //    std::string("..\\..\\app for test\\vm_test.exe")//std::string("..\\..\\app for test\\swhtest.exe")
    //);

    pe_image _module(std::string("..\\..\\app for test\\vm_test.exe"));
    /*

    pe_image_io image_io(_module.get_image(), enma_io_mode_allow_expand);
    image_io.seek_to_end();

    imported_library lib;
    lib.set_library_name("vm_fuku_x86.dll");
    lib.set_rva_iat(image_io.get_image_offset());

    imported_func func;
    func.set_func_name("_fuku_vm_entry@4");
    func.set_iat_rva(image_io.get_image_offset());

    lib.add_item(func);

    _module.get_image_imports().add_library(lib);

    uint8_t jmpvm[] = { 0xFF ,0x25 ,0,0,0,0 };
    *(uint32_t*)&jmpvm[2] = image_io.get_image_offset() + _module.get_image().get_image_base();


    image_io.memory_set(8,0);


    uint32_t rva_vm = image_io.get_image_offset();
    image_io.write(jmpvm, sizeof(jmpvm));
    


    shibari_module _vm_module(
        std::string("..\\Release\\vm_fuku_x86.dll")
    );
    */
    
    furikuri fuku;

    if (fuku.set_image_protect(_module)) {
        //    fuku.add_extended_module(&_vm_module);


        std::vector<uint8_t> out_image;

        //   fuku_ob_settings settings = { 2,2,50.f,50.f,50.f };
        //   fuku.add_ob_code_list({ 0x1000 , 0x6F0 }, &_module, settings);
           //fuku_virtualization_x86 vm;
           //0x1000 , 0x6F0


        fuku_settings_obfuscation ob_set(5, 3, 40.f, 30.f, 40.f,
            FUKU_ASM_SHORT_CFG_USE_EAX_SHORT | FUKU_ASM_SHORT_CFG_USE_DISP_SHORT | FUKU_ASM_SHORT_CFG_USE_IMM_SHORT);

        fuku_settings_obfuscation ob1_set(3, 3, 40.f, 10.f, 60.f, 
            FUKU_ASM_SHORT_CFG_USE_EAX_SHORT | FUKU_ASM_SHORT_CFG_USE_DISP_SHORT);


       fuku.add_ob_code_list({ 0x1000 , 0x6F0 }, ob_set);
     //   fuku.add_ob_code_list({ 0x103A , 0x6B6 }, &_module, ob1_set);
      // fuku.add_ob_code_list({ 0x16F0 , 0x1A6 }, ob1_set);
      //  fuku.add_ob_code_list({ 0x16915 , 0x29 }, &_module, ob1_set);
         /*
        fuku.add_vm_code_list({ 0x16F0 , 0x1A6 }, &_module, fuku_vm_settings({
            { 0,0,00.f,00.f,00.f },// { 2,2,50.f,50.f,50.f },
            &_vm_module,
            _vm_module.get_image_exports().get_items()[0].get_rva(),
            &vm
            }));

        fuku.add_vm_code_list({ 0x1000 , 0x6F0 }, &_module, fuku_vm_settings({
            { 0,0,00.f,00.f,00.f },// { 2,2,50.f,50.f,50.f },
            &_vm_module,
            _vm_module.get_image_exports().get_items()[0].get_rva(),
            &vm
        }));


        fuku.add_vm_code_list({ 0x174B , 0x5F }, &_module, fuku_vm_settings({
            {0, 0, 0, 0, 0},// { 2,2,50.f,50.f,50.f },
            &_vm_module,
            _vm_module.get_image_exports().get_items()[0].get_rva(),
            &vm
        }));

        fuku.add_vm_code_list({ 0x17AA , 0x18 }, &_module, fuku_vm_settings({
            { 0, 0, 0, 0, 0 },// { 2,2,50.f,50.f,50.f },
            &_vm_module,
            _vm_module.get_image_exports().get_items()[0].get_rva(),
            &vm
            }));


        fuku.add_vm_code_list({ 0x17C2 , 0xD4 }, &_module, fuku_vm_settings({
            { 0, 0, 0, 0, 0 },// { 2,2,50.f,50.f,50.f },
            &_vm_module,
            _vm_module.get_image_exports().get_items()[0].get_rva(),
            &vm
            }));
            //*/


            //fuku.add_code_list({ 0x1110 , 0x123 }, fuku_code_type::fuku_code_obfuscate, &_module, { 2,2,50.f,50.f,50.f });


        fuku_settings_mgr fuku_snapshot;

        //if (fuku.create_snapshot(fuku_snapshot, fuku_protect_stage_initialization)) {

        //    while (1) {

                if (fuku.fuku_protect(out_image)) {

                    FILE* hTargetFile;
                    fopen_s(&hTargetFile, "..\\..\\app for test\\fuku_test.exe", "wb");

                    if (hTargetFile) {
                        fwrite(out_image.data(), out_image.size(), 1, hTargetFile);
                        fclose(hTargetFile);

                        printf("fuku_protect good !\n");
                    }
                }
                else {
                    printf("fuku_protect error !\n");
                }

                //Sleep(100);
       //     }
       // }

       

    }
    //  }

      //*/



      
 
      //*/
    return 0;
}
//
//void test_on_shellcode() {
//
//   // srand(0x15464323);
//
//    uint8_t * data_ = new uint8_t[0x1000];
//    uint8_t * data_1 = new uint8_t[0x1000];
//    for (unsigned int i = 0; i < 0x1000 / 4; i += 4) {
//        (*(uint32_t*)&data_[i]) = rand();
//    }
//
//    uint8_t * compressed_buf = new uint8_t[0x1000 + (0x1000 / 16) + 64 + 3];
//    void * work_mem = new uint8_t[LZO1Z_999_MEM_COMPRESS];
//
//    lzo_uint packed_size = 0;
//
//    if (lzo1z_999_compress(data_, 0x1000, compressed_buf, &packed_size, work_mem) != LZO_E_OK) {
//        delete[] work_mem;
//        delete[] compressed_buf;
//        return;
//    }
//    
//    delete[] work_mem;
//    fuku_code_holder code_holder;
//    fuku_code_analyzer anal_code;
//
//#ifdef _M_X64
//    fuku_code_profiler code_profiler(FUKU_ASSAMBLER_ARCH_X64);
//    anal_code.set_arch(fuku_assambler_arch::FUKU_ASSAMBLER_ARCH_X64);
//    anal_code.analyze_code(code_holder, lzo_depack_64, sizeof(lzo_depack_64), 0, 0); 
//#else
//    fuku_code_profiler code_profiler(FUKU_ASSAMBLER_ARCH_X86);
//    anal_code.set_arch(fuku_assambler_arch::FUKU_ASSAMBLER_ARCH_X86);
//  //  anal_code.analyze_code(code_holder, data__, sizeof(data__), 0, 0);
//    
//    anal_code.analyze_code(code_holder, lzo_depack_32, sizeof(lzo_depack_32), 0, 0);
//#endif
//
//    code_profiler.profile_code(code_holder);
//
//    /*
//    typedef int(__stdcall * _md5_algo)(BYTE * sig, BYTE * data, int size);
//
//    BYTE originl_md5buf[16];
//
//    {
//        _md5_algo md5__ = (_md5_algo)(&data__[0]);
//        DWORD old;
//        VirtualProtect(data__, sizeof(data__), PAGE_EXECUTE_READWRITE, &old);
//        md5__(originl_md5buf, compressed_buf, packed_size);
//    }
//    */
//
//    typedef int(__cdecl * _depack_algo)(const unsigned char * src, unsigned long  src_len, unsigned char * dst, unsigned long * dst_len, void * wrkmem);
//    for (unsigned int i = 0; i < 10000; i++) {
//
//        if (i == 52) {
////            __debugbreak();
//        }
//
//        fuku_code_analyzer ob_anal_code = code_holder;
//
//        fuku_obfuscator obfuscator;
//
//
//        fuku_settings_obfuscation ob_set(4, 5, 30.f, 30.f, 30.f,
//            FUKU_ASM_SHORT_CFG_USE_EAX_SHORT | FUKU_ASM_SHORT_CFG_USE_DISP_SHORT | FUKU_ASM_SHORT_CFG_USE_IMM_SHORT, false, false);
//        obfuscator.set_destination_virtual_address(0);
//        // obfuscator.set_settings({ 1,1,00.f,00.f,30.f });
//        obfuscator.set_settings(ob_set);
//        obfuscator.set_code(&ob_anal_code.get_code());
//
//        unsigned int s_time = GetTickCount();
//
//        obfuscator.obfuscate_code();
//        std::map<uint64_t, uint64_t> associations;
//        std::vector<fuku_image_relocation> relocations;
//                    
//        ob_anal_code.get_code().finalize_code(&associations, &relocations);
//
//        std::vector<uint8_t> __obf_unpacker = ob_anal_code.get_code().dump_code();
//
//        printf("%08x : %d obfuscated in %.4f sec | size scale %.2f | %.3f MIB | ", 
//            GetCurrentThreadId(), i, 
//            (GetTickCount() - s_time) / 1000.f, (float)__obf_unpacker.size() / sizeof(lzo_depack_32),
//            (float)__obf_unpacker.size() / (float)(1024 * 1024));
//
//        uint8_t * __obf_unpacker_ = __obf_unpacker.data();
//
//        DWORD old_p;
//        VirtualProtect(__obf_unpacker_, __obf_unpacker.size(), PAGE_EXECUTE_READWRITE, &old_p);
//        
//        _depack_algo depack = (_depack_algo)(__obf_unpacker_ + associations.begin()->second);
//       // _md5_algo md5__ = (_md5_algo)(__obf_unpacker_ + associations.begin()->second);
//        unsigned long unpack_size = 0x1000;
//
//#ifdef _M_X64
//        for (auto &rel : relocations) { //fix reloc
//            *(uint64_t*)&__obf_unpacker_[rel.virtual_address] += (uint64_t)__obf_unpacker_;
//        }     
//#else
//        for (auto &rel : relocations) { //fix reloc
//            *(uint32_t*)&__obf_unpacker_[rel.virtual_address] += (uint32_t)__obf_unpacker_;
//        }
//#endif
//        unsigned int n_time = GetTickCount();
//
//        if (i == 52) {
//         //   code_profiler.print_code(ob_anal_code.get_code());
//        }
//
//    //    code_profiler.print_code(ob_anal_code.get_code());
//        // __try {
//     //   BYTE md5buf[16];
//      //  md5__(md5buf, compressed_buf, packed_size);
//         depack(compressed_buf, packed_size, data_1, &unpack_size, 0);
//        // }
//        // __except (1) {
//          //   system("PAUSE");
//        // }
//        
//        printf(" called in %.4f sec | ", (GetTickCount() - n_time) / 1000.f);
//        
//        /*
//        if (!memcmp(originl_md5buf, md5buf, sizeof(md5buf))) {
//            printf("good ! \n");
//        }
//        else {
//            code_profiler.print_code(ob_anal_code.get_code());
//            printf("error ! \n");
//        }
//        */
//
//        for (unsigned int i = 0; i < 0x1000; i++) {
//            if (data_[i] != data_1[i]) { 
//                printf("error! %x != %x : %d\n", data_[i], data_1[i], i); 
//                
//          //      Sleep(100000);
//
//                
//            }
//        }
//        
//
//        printf("good!\n");
//    }
//}